home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / contrib / pdcurs22 / src / portable / refresh.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-26  |  9.2 KB  |  335 lines
  1. /*
  2. ***************************************************************************
  3. * This file comprises part of PDCurses. PDCurses is Public Domain software.
  4. * You may use this code for whatever purposes you desire. This software
  5. * is provided AS IS with NO WARRANTY whatsoever.
  6. * Should this software be used in another application, an acknowledgement
  7. * that PDCurses code is used would be appreciated, but is not mandatory.
  8. *
  9. * Any changes which you make to this software which may improve or enhance
  10. * it, should be forwarded to the current maintainer for the benefit of 
  11. * other users.
  12. *
  13. * The only restriction placed on this code is that no distribution of
  14. * modified PDCurses code be made under the PDCurses name, by anyone
  15. * other than the current maintainer.
  16. * 
  17. * See the file maintain.er for details of the current maintainer.
  18. ***************************************************************************
  19. */
  20. #include <string.h>
  21. #define    CURSES_LIBRARY    1
  22. #include <curses.h>
  23.  
  24. #ifndef NO_MEMORY_H
  25. #include <memory.h>
  26. #endif
  27.  
  28. /* undefine any macros for functions defined in this module */
  29. #undef    refresh
  30. #undef    wrefresh
  31. #undef    wnoutrefresh
  32. #undef    doupdate
  33. #undef    redrawwin
  34. #undef    wredrawln
  35.  
  36. /* undefine any macros for functions called by this module if in debug mode */
  37. #ifdef PDCDEBUG
  38. #  undef    wattrset
  39. #  undef    mvwprintw
  40. #  undef    wmove
  41. #  undef    wattrset
  42. #  undef    touchwin
  43. #  undef    reset_prog_mode
  44. #endif
  45.  
  46. #ifdef PDCDEBUG
  47. char *rcsid_refresh  = "$Id$";
  48. #endif
  49.  
  50. /*man-start*********************************************************************
  51.  
  52.   Name:                                                       refresh
  53.  
  54.   Synopsis:
  55.       int    refresh(void);
  56.       int    wrefresh(WINDOW *win);
  57.       int    wnoutrefresh(register WINDOW *win);
  58.       int    doupdate(void);
  59.       int    redrawwin(WINDOW *win);
  60.       int    redrawln(WINDOW *win, int beg_line, int num_lines);
  61.  
  62.   X/Open Description:
  63.      The routine wrefresh() copies the named window to the physical
  64.      terminal screen, taking into account what is already there in
  65.      order to optimize cursor movement.
  66.      The routine refresh() does the same, using stdscr as a default
  67.      screen.
  68.      These routines must be called to get any output on the
  69.      terminal, as other routines only manipulate data structures.
  70.      Unless leaveok has been enabled, the physical cursor of the
  71.      terminal is left at the location of the window's cursor.
  72.  
  73.      The wnoutrefresh() and doupdate() routines allow multiple updates
  74.      with more efficiency than wrefresh() alone.  In addition to all 
  75.      of the window structures representing the terminal screen: a physical
  76.      screen, describing what is actually on the screen and a virtual screen,
  77.      describing what the programmer wants to have on the screen.
  78.  
  79.      The wrefresh() function works by first calling wnoutrefresh(),
  80.      which copies the named window to the virtual screen.  It then
  81.      calls doupdate(), which compares the virtual screen to the
  82.      physical screen and does the actual update.  If the programmer
  83.      wishes to output several windows at once, a series of cals to
  84.      wrefresh() will result in alternating calls to wnoutrefresh()
  85.      and doupdate(), causing several bursts of output to the
  86.      screen.  By first calling wnoutrefresh() for each window, it
  87.      is then possible to call doupdate() once.  This results in
  88.      only one burst of output, with probably fewer total characters
  89.      transmitted and certainly less CPU time used.
  90.  
  91.   X/Open Return Value:
  92.      All functions return OK on success and ERR on error.
  93.  
  94.   X/Open Errors:
  95.      No errors are defined for this function.
  96.  
  97.   Portability                             X/Open    BSD    SYS V
  98.                                           Dec '88
  99.       refresh                               Y        Y       Y
  100.       wrefresh                              Y        Y       Y
  101.       wnoutrefresh                          Y        Y       Y
  102.       doupdate                              Y        Y       Y
  103.       redrawwin                             -        -      4.0
  104.       wredrawln                             -        -      4.0
  105.  
  106. **man-end**********************************************************************/
  107.  
  108. /***********************************************************************/
  109. int    refresh( void )
  110. /***********************************************************************/
  111. {
  112. #ifdef PDCDEBUG
  113.     if (trace_on) PDC_debug("refresh() - called\n");
  114. #endif
  115.  
  116.     return( wrefresh(stdscr) );
  117. }
  118. /***********************************************************************/
  119. int    wrefresh(WINDOW *win)
  120. /***********************************************************************/
  121. {
  122. #ifdef PDCDEBUG
  123.     if (trace_on) PDC_debug("wrefresh() - called\n");
  124. #endif
  125.  
  126.     if (win == (WINDOW *)NULL)    return( ERR );
  127.     if (win->_flags & _PAD)    return( ERR );
  128.     if (win->_flags & _SUBPAD)    return( ERR );
  129.  
  130.     if (win == curscr)
  131.         curscr->_clear = TRUE;
  132.     else    
  133.         wnoutrefresh(win);
  134.     doupdate();
  135.     return( OK );
  136. }
  137. /***********************************************************************/
  138. int    wnoutrefresh(WINDOW *win)
  139. /***********************************************************************/
  140. {
  141. register int        first;    /* first changed char on line */
  142. register int        last;    /* last changed char on line  */
  143.     int        begy;    /* window's place on screen   */
  144.     int        begx;
  145.     int        i;
  146.     int        j;
  147.     int        y;
  148.     int        x;
  149.     int        len;
  150.     chtype        attrs;
  151.  
  152. #ifdef PDCDEBUG
  153.     if (trace_on) PDC_debug("wnoutrefresh() - called\n");
  154. #endif
  155.  
  156.     if (win == (WINDOW *)NULL)
  157.         return( ERR );
  158.  
  159.     if ((win->_flags == _PAD)
  160.     ||  (win->_flags == _SUBPAD))
  161.         return( ERR );
  162.  
  163.     y = win->_cury;
  164.     x = win->_curx;
  165.     attrs = win->_attrs;
  166.     if (win->_title != NULL)
  167.         len = strlen(win->_title);
  168.     /*
  169.      * There may be a better place to implement window titles, but this
  170.      * seems to be the best place. -- Frotz
  171.      */
  172.     if ((len > 0) 
  173.     && (win->_title != NULL) 
  174.     && !(win->_flags & _SUBWIN)
  175.     && !(win->_flags & _SUBPAD))
  176.     {
  177.         wattrset(win, win->_title_attr);
  178.         mvwprintw(win, 0, (win->_title_ofs), "%s", (long) win->_title);
  179.         wmove(win, y, x);    /* restore cursor postion */
  180.         wattrset(win, attrs);    /* restore attributes      */
  181.     }
  182.  
  183.     if (win->_flags & _PAD)
  184.         return( ERR );
  185.  
  186.     begy = win->_begy;
  187.     begx = win->_begx;
  188.  
  189.     for (i = 0, j = begy; i < win->_maxy; i++, j++)
  190.     {
  191.         if (win->_firstch[i] != _NO_CHANGE)
  192.         {
  193.             first = win->_firstch[i];
  194.             last = win->_lastch[i];
  195.  
  196.             memcpy(&(curscr->_y[j][begx + first]),
  197.                    &(win->_y[i][first]),
  198.                    (last - first + 1) * sizeof(chtype));
  199.  
  200.             first += begx;    /* s's min/max change positions */
  201.             last += begx;
  202.  
  203.             if (curscr->_firstch[j] != _NO_CHANGE)
  204.                 curscr->_firstch[j] = min(curscr->_firstch[j], first);
  205.             else
  206.                 curscr->_firstch[j] = first;
  207.  
  208.             curscr->_lastch[j] = max(curscr->_lastch[j], last);
  209.  
  210.             win->_firstch[i] = _NO_CHANGE;    /* updated now */
  211.         }
  212.         win->_lastch[i] = _NO_CHANGE;    /* updated now */
  213.     }
  214.  
  215.     if (win->_clear)
  216.     {
  217.         win->_clear = FALSE;
  218.     }
  219.  
  220.     if (!win->_leave)
  221.     {
  222.         curscr->_cury = win->_cury + begy;
  223.         curscr->_curx = win->_curx + begx;
  224.     }
  225.     return( OK );
  226. }
  227. /***********************************************************************/
  228. int    doupdate(void)
  229. /***********************************************************************/
  230. {
  231. register int    i;
  232. bool rc;
  233. #ifdef    REGISTERWINDOWS
  234.     WINDS*    next = _cursvar.visible;
  235. #endif
  236.  
  237. #ifdef PDCDEBUG
  238.     if (trace_on) PDC_debug("doupdate() - called\n");
  239. #endif
  240.  
  241. #ifdef    REGISTERWINDOWS
  242.     if (_cursvar.refreshall)
  243.     {
  244.         while (next != NULL)
  245.         {
  246.             if (next->w->_parent != NULL)
  247.             {
  248.                 touchwin(next->w->_parent);
  249.                 wnoutrefresh(next->w->_parent);
  250.             }
  251.             touchwin(next->w);
  252.             wnoutrefresh(next->w);
  253.             next = next->next;
  254.         }
  255.     }
  256. #endif
  257.  
  258.     if  (_cursvar.shell)
  259.         reset_prog_mode();
  260.  
  261.     if (curscr == (WINDOW *)NULL)
  262.         return( ERR );
  263.  
  264. /* if checking for typeahead, bail out here if any is found */
  265.  
  266.     
  267.     if (_cursvar.refrbrk && (_cursvar.cbreak || _cursvar.raw_inp)) 
  268.     {
  269.         rc = PDC_breakout();     
  270.         if(rc)
  271.             return( OK );
  272.     }
  273.  
  274.     if (curscr->_clear)
  275.     {
  276.         PDC_clr_update(curscr);
  277.     }
  278.     else
  279.     {
  280.         for (i = 0; i < LINES; i++)
  281.         {
  282.             if (curscr->_firstch[i] != _NO_CHANGE)
  283.                 if (PDC_transform_line(i))  /* if test new */
  284.                     break;
  285.         }
  286.     }
  287.  
  288. #if defined (XCURSES)
  289.     XCurses_wait_for_display();
  290. #endif
  291.  
  292.     PDC_gotoxy(curscr->_cury, curscr->_curx);
  293.     _cursvar.cursrow = curscr->_cury;
  294.     _cursvar.curscol = curscr->_curx;
  295.  
  296.     return( OK );
  297. }
  298. /***********************************************************************/
  299. int    redrawwin(WINDOW *win)
  300. /***********************************************************************/
  301. {
  302.     register int i;
  303.  
  304. #ifdef PDCDEBUG
  305.     if (trace_on) PDC_debug("redrawwin() - called\n");
  306. #endif
  307.  
  308.     if (win == (WINDOW *)NULL)
  309.         return( ERR );
  310.  
  311.     return(wredrawln(win,0,win->_maxy));
  312. }
  313. /***********************************************************************/
  314. int    wredrawln(WINDOW *win, int start, int num)
  315. /***********************************************************************/
  316. {
  317.     register int i;
  318.  
  319. #ifdef PDCDEBUG
  320.     if (trace_on) PDC_debug("wredrawln() - called\n");
  321. #endif
  322.  
  323.     if (win == (WINDOW *)NULL)
  324.         return( ERR );
  325.  
  326.     if  (start > win->_maxy || start + num > win->_maxy)
  327.         return( ERR );
  328.     for(i=start;i<start+num;i++)
  329.        {
  330.         win->_firstch[i] = 0;
  331.         win->_lastch[i] = win->_maxx - 1;
  332.        }
  333.     return( OK );
  334. }
  335.